Language/OS - Multiplatform Resource Library/LANGUAGE OS.iso/cpp_libs/varia/interp18.lha/interp-1.8/Ast.h

C/C++ Source or Header | 1990-01-22 | 6KB | 263 lines

// -*- C++ -*- Ast.h --- the class declaration for an abstract syntax tree.
// Copyright (C) 1989 Carey Richard Murphey.
// ([e-mail]) 5310 Rutherglenn, Houston, TX 77096

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 1, or (at your option)
// any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

#ifndef _Ast_defs_h_
#pragma once
#define _Ast_defs_h_ 1
#include <String.h>
#include "Context.h"


/* Nodes in the Abstract syntax tree have three in common.  For some
`Node *p':

   1. p->eval() evaluates the node or subtree connected to it.

   2. p->echo(Stream) prints an equivalent source language representation
      of the node or subtree on the specified stream.

*/


class Node            // a node in the Ast.
{
public:
  Node () {}
  virtual double eval () = 0;
  virtual ostream& echo (ostream& Stream) = 0;
  friend ostream& operator << (ostream& Stream, Node* p);
  operator double ();
};

class NoOp : public Node
{
public:
  NoOp () : Node() {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class UnOp : public Node
{
protected:
  Node *left;
public:
  UnOp (Node *l) : left(l), Node() {}
  ~UnOp () {delete left;}
  virtual double eval () = 0;
  virtual ostream& echo (ostream& Stream) = 0;
};

class BinOp : public Node
{
protected:
  Node *left, *right;
public:
  BinOp (Node *l, Node *r) : left(l), right(r), Node() {}
  ~BinOp () {delete left; delete right;}
  virtual double eval () = 0;
  virtual ostream& echo (ostream& Stream) = 0;
};

class Sym : public Node
{
protected:
  String name;
  Table table;
public:
  Sym (String s, Table t) : name(s), table(t), Node() {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
  virtual operator int ();
  virtual operator double ();
  virtual double func (double p);
  virtual void assign (double p);
};

class SymUnOp : public Node
{
protected:
  Sym *left;
public:
  SymUnOp (Sym *l) : left(l), Node() {}
  ~SymUnOp () {delete left;}
  virtual double eval () = 0;
  virtual ostream& echo (ostream& Stream) = 0;
};

class SymBinOp : public Node
{
protected:
  Sym *left;
  Node *right;
public:
  SymBinOp (Sym *l, Node *r) : left(l), right(r), Node() {}
  ~SymBinOp () {delete left; delete right;}
  virtual double eval () = 0;
  virtual ostream& echo (ostream& Stream) = 0;
};

class Func : public SymBinOp
{
public:
  Func (Sym *l, Node *r) : SymBinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Assign : public SymBinOp
{
public:
  Assign (Sym *l, Node *r) : SymBinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class PostIncrement : public SymUnOp
{
public:
  PostIncrement (Sym *l) : SymUnOp (l) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class PostDecrement : public SymUnOp
{
public:
  PostDecrement (Sym *l) : SymUnOp (l) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class PreIncrement : public SymUnOp
{
public:
  PreIncrement (Sym *l) : SymUnOp (l) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class PreDecrement : public SymUnOp
{
public:
  PreDecrement (Sym *l) : SymUnOp (l) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class If : public BinOp
{
public:
  If (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class While : public BinOp
{
public:
  While (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Statements : public BinOp
{
public:
  Statements (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Plus : public BinOp
{
public:
  Plus (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Minus : public BinOp
{
public:
  Minus (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Times : public BinOp
{
public:
  Times (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Divide : public BinOp
{
public:
  Divide (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Pow : public BinOp
{
public:
  Pow (Node *l, Node *r) : BinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Double : public Node
{
protected:
  double value;
public:
  Double (double v) : value (v), Node() {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Uminus : public UnOp
{
public:
  Uminus (Node *l) : UnOp (l) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

class Double_Func : public SymBinOp
{
  Table symtab;            // the local symbol table holding the arguemnts.
public:
  Func (Sym *l, Node *r) : SymBinOp (l, r) {}
  virtual double eval ();
  virtual ostream& echo (ostream& Stream);
};

#if defined(__OPTIMIZE__) && !defined(INLINE)
#define INLINE inline
#include "Ast.cc"
#ifdef INLINE
#undef INLINE
#endif
#endif

#endif